import pagesJson from '@/pages.json'
import config from '@/uni_modules/uni-id-pages/config.js'

const uniIdCo = uniCloud.importObject("uni-id-co")
const db = uniCloud.database();
const usersTable = db.collection('uni-id-users')

let hostUserInfo = uni.getStorageSync('uni-id-pages-userInfo')||{}

const data = {
	userInfo: hostUserInfo,
	hasLogin: Object.keys(hostUserInfo).length != 0
}

// 定义 mutations, 修改属性
export const mutations = {
	// data不为空，表示传递要更新的值(注意不是覆盖是合并),什么也不传时，直接查库获取更新
	async updateUserInfo(data = false) {
		if (data) {
			try {
				// 创建数据的副本，确保不修改原始数据
				const dataToUpdate = {...data};
				
				// 删除不在数据库schema中的字段，避免验证错误
				if (dataToUpdate.hasOwnProperty('realNameAuth')) {
					// 如果有realNameAuth字段，单独存储但不发送到数据库
					const realNameAuth = dataToUpdate.realNameAuth;
					delete dataToUpdate.realNameAuth;
					
					// 将实名认证信息存储在本地
					if (realNameAuth) {
						uni.setStorageSync('uni-id-pages-realNameAuth', realNameAuth);
					}
				}
				
				// 只有在有字段需要更新时才调用云对象
				if (Object.keys(dataToUpdate).length > 0) {
					// 使用uni-id-co云对象更新用户资料，而不是直接操作数据库
					const uniIdCo = uniCloud.importObject("uni-id-co");
					// 获取当前用户ID
					const uid = uniCloud.getCurrentUserInfo().uid;
					
					// 如果没有提供username，则从当前用户信息中获取
					if (!dataToUpdate.username && store.userInfo && store.userInfo.username) {
						dataToUpdate.username = store.userInfo.username;
					}
					
					// 添加uid参数到请求中
					const result = await uniIdCo.updateUser({
						...dataToUpdate,
						uid
					});
					
					if (result.code === 0 || result.errCode === 0) {
						uni.showToast({
							title: "更新成功",
							icon: 'none',
							duration: 3000
						});
						this.setUserInfo(dataToUpdate);
					} else {
						uni.showToast({
							title: result.message || "更新失败",
							icon: 'none',
							duration: 3000
						});
					}
				} else {
					// 如果只有realNameAuth字段，那么只在本地更新
					this.setUserInfo(data);
				}
			} catch (error) {
				console.error("更新用户信息失败:", error);
				uni.showToast({
					title: error.message || "更新失败",
					icon: 'none',
					duration: 3000
				});
			}

		} else {
      // 不等待联网查询，立即更新用户_id确保store.userInfo中的_id是最新的
      const _id = uniCloud.getCurrentUserInfo().uid
      this.setUserInfo({_id},{cover:true})
      // 查库获取用户信息，更新store.userInfo
			const uniIdCo = uniCloud.importObject("uni-id-co", {
				customUI: true
			})
			try {
				let res = await usersTable.where("'_id' == $cloudEnv_uid")
					.field('mobile,nickname,username,email,avatar_file')
					.get()

				const realNameRes = await uniIdCo.getRealNameInfo()

				// console.log('fromDbData',res.result.data);
				// 存储用户基本信息 - 不包含realNameAuth，因为它不是数据库中的字段
				this.setUserInfo({
					...res.result.data[0]
				})
				
				// 单独在本地存储实名认证信息，避免写入数据库
				if(realNameRes) {
					uni.setStorageSync('uni-id-pages-realNameAuth', realNameRes)
				}
			} catch (e) {
				this.setUserInfo({},{cover:true})
				console.error(e.message, e.errCode);
			}
		}
	},
	setUserInfo(data, {cover}={cover:false}) {
		// console.log('set-userInfo', data);
		
		// 检查是否有realNameAuth字段，如果有则单独处理
		const dataToStore = {...data};
		if (dataToStore.hasOwnProperty('realNameAuth')) {
			// 从将要存储的用户信息中移除realNameAuth
			const realNameAuth = dataToStore.realNameAuth;
			delete dataToStore.realNameAuth;
			
			// 将实名认证信息单独存储
			if (realNameAuth) {
				uni.setStorageSync('uni-id-pages-realNameAuth', realNameAuth);
			}
			
			// 在内存中保留该信息以供使用
			// 但确保不会写入数据库
			const inMemoryOnly = {realNameAuth};
		}
		
		let userInfo = cover ? dataToStore : Object.assign(store.userInfo, dataToStore)
		store.userInfo = Object.assign({}, userInfo)
		
		// 将实名认证信息放回到内存中的store.userInfo，但不写入存储的userInfo
		const storedRealNameAuth = uni.getStorageSync('uni-id-pages-realNameAuth');
		if (storedRealNameAuth) {
			// 仅在内存中添加，不影响存储
			store.userInfo.realNameAuth = storedRealNameAuth;
		}
		
		store.hasLogin = Object.keys(store.userInfo).length != 0
		
		// 确保不将realNameAuth存入用户信息存储中
		const userInfoToStore = {...store.userInfo};
		if (userInfoToStore.hasOwnProperty('realNameAuth')) {
			delete userInfoToStore.realNameAuth;
		}
		
		// console.log('store.userInfo', store.userInfo);
		uni.setStorageSync('uni-id-pages-userInfo', userInfoToStore)
		return data
	},
	async logout() {
		try {
			// 1. 已经过期就不需要调用服务端的注销接口	2.即使调用注销接口失败，不能阻塞客户端
			if(uniCloud.getCurrentUserInfo().tokenExpired > Date.now()){
				try{
					await uniIdCo.logout()
				}catch(e){
					console.error("注销接口调用失败:", e);
					// 继续处理，即使接口失败
				}
			}
			
			// 清除所有相关的存储
			uni.removeStorageSync('uni_id_token');
			uni.removeStorageSync('uni_id_token_expired');
			uni.removeStorageSync('uni-id-pages-userInfo');
			
			// 清除实名认证信息
			uni.removeStorageSync('uni-id-pages-realNameAuth');
			
			// 清除内存中的用户信息
			this.setUserInfo({},{cover:true});
			
			// 触发登出事件
			uni.$emit('uni-id-pages-logout');
			
			// 跳转到登录页面
			const loginPage = pagesJson.uniIdRouter && pagesJson.uniIdRouter.loginPage 
				? pagesJson.uniIdRouter.loginPage
				: 'uni_modules/uni-id-pages/pages/login/login-withoutpwd';
				
			// 使用reLaunch而不是redirectTo，确保清除导航栈
			uni.reLaunch({
				url: `/${loginPage}`,
				fail: (err) => {
					console.error("跳转到登录页失败:", err);
					// 如果跳转失败，尝试使用redirectTo
					uni.redirectTo({
						url: `/${loginPage}`,
						fail: (redirectErr) => {
							console.error("重定向到登录页也失败:", redirectErr);
							// 最后尝试使用switchTab
							uni.switchTab({
								url: '/pages/explore/index',
								fail: (finalErr) => {
									console.error("所有跳转方式都失败:", finalErr);
								}
							});
						}
					});
				}
			});
		} catch (error) {
			console.error("注销过程中出错:", error);
			// 确保即使出错也清除本地存储
			uni.removeStorageSync('uni_id_token');
			uni.removeStorageSync('uni_id_token_expired');
			uni.removeStorageSync('uni-id-pages-userInfo');
			uni.removeStorageSync('uni-id-pages-realNameAuth');
			
			// 显示错误信息
			uni.showToast({
				title: "注销过程中出现错误",
				icon: 'none',
				duration: 3000
			});
		}
	},
	loginBack (e = {}) {
		const {uniIdRedirectUrl = ''} = e
		let delta = 0; //判断需要返回几层
		let pages = getCurrentPages();
		// console.log(pages);
		pages.forEach((page, index) => {
			if (pages[pages.length - index - 1].route.split('/')[3] == 'login') {
				delta++
			}
		})
		// console.log('判断需要返回几层:', delta);
		if (uniIdRedirectUrl) {
			return uni.redirectTo({
				url: uniIdRedirectUrl,
				fail: (err1) => {
					uni.switchTab({
						url:uniIdRedirectUrl,
						fail: (err2) => {
							console.log(err1,err2)
						}
					})
				}
			})
		}
		// #ifdef H5
		if (e.loginType == 'weixin') {
			// console.log('window.history', window.history);
			return window.history.go(-3)
		}
		// #endif

		if (delta) {
			const page = pagesJson.pages[0]
			return uni.reLaunch({
				url: `/${page.path}`
			})
		}

		uni.navigateBack({
			delta
		})
	},
	loginSuccess(e = {}){
		const {
			showToast = true, toastText = '登录成功', autoBack = true, uniIdRedirectUrl = '', passwordConfirmed
		} = e
		// console.log({toastText,autoBack});
		if (showToast) {
			uni.showToast({
				title: toastText,
				icon: 'none',
				duration: 3000
			});
		}
		
		// 异步获取最新的用户信息
		setTimeout(async () => {
			try {
				// 使用uni-id-co云对象获取用户信息
				const uniIdCo = uniCloud.importObject("uni-id-co", {
					customUI: true
				});
				const checkTokenRes = await uniIdCo.checkToken({
					token: uni.getStorageSync('uni_id_token')
				});
				
				if (checkTokenRes.code === 0 && checkTokenRes.userInfo) {
					// 更新用户信息
					this.setUserInfo(checkTokenRes.userInfo);
				} else {
					console.error("获取用户信息失败:", checkTokenRes.message);
					// 回退到常规的方式获取用户信息
					this.updateUserInfo();
				}
			} catch (error) {
				console.error("登录后获取用户信息失败:", error);
				// 回退到常规的方式
				this.updateUserInfo();
			}
		}, 0);

		// 触发登录成功事件
		uni.$emit('uni-id-pages-login-success')

		if (config.setPasswordAfterLogin && !passwordConfirmed) {
			return uni.redirectTo({
				url: uniIdRedirectUrl ? `/uni_modules/uni-id-pages/pages/userinfo/set-pwd/set-pwd?uniIdRedirectUrl=${uniIdRedirectUrl}&loginType=${e.loginType}`: `/uni_modules/uni-id-pages/pages/userinfo/set-pwd/set-pwd?loginType=${e.loginType}`,
				fail: (err) => {
					console.log(err)
				}
			})
		}

		if (autoBack) {
			this.loginBack({uniIdRedirectUrl})
		}
	}

}

// #ifdef VUE2
import Vue from 'vue'
// 通过Vue.observable创建一个可响应的对象
export const store = Vue.observable(data)
// #endif

// #ifdef VUE3
import {
	reactive
} from 'vue'
// 通过Vue.observable创建一个可响应的对象
export const store = reactive(data)
// #endif
